Open a new cursor P1 to a transient table. The cursor is always opened read/write even if the main database is read-only. The ephemeral table is deleted automatically when the cursor is closed.
If the cursor P1 is already opened on an ephemeral table, the table is cleared (all content is erased).

P2 is the number of columns in the ephemeral table. The cursor points to a BTree table if P4==0 and to a BTree index if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure that defines the format of keys in the index.

pub struct EphemeralTable<Key: Ord> {
    pub rows: BTreeMap<Key, Vec<OwnedValue>>,
    pub next_rowid: u64,                      // generate rowids
    pub columns: Vec<Column>,                 // columns
}

enum Ephemeral {
  Table(EphemeralTable)
  Index(EphemeralIndex)
}

CREATE TABLE a(foo);
CREATE TABLE b(foo);
INSERT INTO a VALUES (1);
INSERT INTO b VALUES (2);

SELECT a.foo, b.foo FROM a LEFT JOIN b on a.foo = b.foo;
1|NULL

struct EphemeralTable<'a> {
    set: BTreeSet<usize>,
    iterator: RefCell<Option<std::collections::btree_set::Range<'a, usize>>>,
    current: RefCell<Option<usize>>,
}

impl<'a> EphemeralTable<'a> {
    fn new() -> Self {
        Self { set: BTreeSet::new(), iterator: RefCell::new(None), current: RefCell::new(None) }
    }

    fn next(&'a self) {
        if self.iterator.borrow().is_none() {
            *self.iterator.borrow_mut() = Some(self.set.range(..));
        }
        *self.current.borrow_mut() = self.iterator.borrow_mut().as_mut().unwrap().next().cloned();
    }
    
    fn prev(&'a self) {
        if self.iterator.borrow().is_none() {
            *self.iterator.borrow_mut() = Some(self.set.range(..));
        }
        *self.current.borrow_mut() = self.iterator.borrow_mut().as_mut().unwrap().next_back().cloned();
    }

    fn seek(&'a self, value: usize) {
        let range = self.set.range(value..);
        self.iterator.borrow_mut().replace(range);
        *self.current.borrow_mut() = self.iterator.borrow_mut().as_mut().unwrap().next().cloned();
    }

    fn insert(&mut self, value: usize) {
        self.set.insert(value);
    }

    fn current(&self) -> Option<usize> {
        self.current.borrow().clone()
    }
}

pub enum GeneralBTreeCursor {
  Persistent(&'a mut BTreeCursor),
  Ephemeral(&'a mut EphemeralCursor)
}

impl <'a> GeneralBTreeCursor<'a> {
  fn rewind(...) {
    match self {
       Self::Persistent(p) => c.rewind(...)),
       Self::Ephemeral(e) => e.rewind(...)),
    }
  }
}